package com.ad.payload.util;


import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author dxgong
 * @日期 2018/8/7 12:40
 * @注释: 字符串相关工具类, 此处工具类调用commons.lang3.StringUtls，不能在业务代码直接调用第三方工具类，必须重新自己进行封装
 */
public class StringUtil {

    /**
     * 校验正整数
     */
    public static final String POSITIVENUMBER = "/^([1-9]\\d*|[0]{1,1})$/";

    /**
     * 替换字符串
     */
    public static String replace(String str, String searchStr, String replaceStr) {
        return StringUtils.replace(str, searchStr, replaceStr);
    }


    /**
     * 按位数切割字符串
     *
     * @param str   要切割的字符串
     * @param start 开始坐标，从0开始
     * @param end   结束坐标
     */
    public static String substring(String str, Integer start, Integer end) {
        return StringUtils.substring(str, start, end);
    }

    /**
     * 按位数切割字符串
     *
     * @param str   要切割的字符串
     * @param start 开始坐标，从0开始
     */
    public static String substring(String str, Integer start) {
        return StringUtils.substring(str, start);
    }

    /**
     * 字符串判断不为空
     *
     * @param str 字符串
     * @return true 不为空，false 为空
     */
    public static Boolean isNotBlank(String str) {
        if ("null".equals(str)) {
            return false;
        }
        return StringUtils.isNotBlank(str);
    }

    /**
     * 字符串判断为空
     *
     * @param str 字符串
     * @return true 为空，false 不为空
     */
    public static Boolean isBlank(String str) {
        if ("null".equals(str)) {
            return true;
        }
        return StringUtils.isBlank(str);
    }

    /**
     * 切割字符串
     *
     * @param str        字符串
     * @param separamtor 切割符
     * @return String[] 字符串数组
     */
    public static String[] splits(String str, String separamtor) {
        return StringUtils.split(str, separamtor);
    }


    /**
     * 字符判断：是否为正整数
     *
     * @param str 字符串
     * @return true 是，false 否
     */
    public static Boolean isPositiveNumber(String str) {
        return checkPattern(str.trim(),
                POSITIVENUMBER);
    }

    /**
     * 去除字符串空格
     *
     * @param str 字符串
     * @return String 字符串
     */
    public static String trim(String str) {
        return StringUtils.trim(str);
    }



    /**
     * 字符判断：是否为正整数
     *
     * @param num 数字
     * @return true 是，false 否
     */
    public static Boolean isPositiveNumber(Integer num) {
        return checkPattern(String.valueOf(num).trim(),
                POSITIVENUMBER);
    }

    /**
     * 返回分隔符字符串
     * @param list
     * @param point 分隔符号
     * @return
     */
//    public static String listToString(List list,String point){
//        String listString = Joiner.on(point).join(list);
//        return listString;
//    }

    /**
     * 判断字符串是否满足正则
     *
     * @param str     需要判断的字符串
     * @param pattern 正则
     * @return 判断结果
     */
    public static boolean checkPattern(String str, String pattern) {
        try {
            if (pattern.startsWith("/")) {
                pattern = pattern.substring(1);
            }
            if (pattern.endsWith("/")) {
                pattern = pattern.substring(0, pattern.length() - 1);
            }
            return str.matches(pattern);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 比较字符串
     *
     * @param str1 str1
     * @param str2 str2
     */
    public static boolean equalsStr(String str1, String str2) {
        return StringUtils.equals(str1, str2);
    }


    /**
     * object 转 integer
     *
     * @param obj obj
     */
    public static Integer objToInteger(Object obj) {
        if (!(obj instanceof Integer)) {
            return null;
        }
        return Integer.valueOf(String.valueOf(obj));
    }

    /**
     * 统计某字符在某字符串里面出现次数
     *
     * @param str      被统计的字符串
     * @param countStr 需要统计的字符串
     */
    public static Integer countStr(String str, String countStr) {
        int count = 0;
        while (str.indexOf(countStr) != -1) {

            str = str.substring(str.indexOf(countStr) + 1, str.length());
            count++;

        }
        System.out.println(countStr + "出现的次数为" + count + "次");
        return count;
    }


    /*
     *MD5加密
     * @param null
     * @return
     * @author huangmj
     * @creed: Talk is cheap,show me the code
     * @date 2018-12-05 14:19
     */
    public static String getMd5(String plainText) {
        try {
            MessageDigest md = MessageDigest.getInstance("md5");
            md.update(plainText.getBytes());
            byte b[] = md.digest();

            int i;

            StringBuffer buf = new StringBuffer("");
            for (int offset = 0; offset < b.length; offset++) {
                i = b[offset];
                if (i < 0)
                    i += 256;
                if (i < 16)
                    buf.append("0");
                buf.append(Integer.toHexString(i));
            }
            //32位加密
            return buf.toString();
            // 16位的加密
            //return buf.toString().substring(8, 24);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }

    /*
     *
     * @param unicode
     * @return java.lang.String
     * @author huangmj
     * @creed: Talk is cheap,show me the code
     * @date 2018-12-05 11:15
     */
    public static String unicodeToCn(String unicode) {
        /** 以 \ u 分割，因为java注释也能识别unicode，因此中间加了一个空格*/
        String[] strs = unicode.split("\\\\u");
        String returnStr = "";
        // 由于unicode字符串以 \ u 开头，因此分割出的第一个字符是""。
        for (int i = 1; i < strs.length; i++) {
            returnStr += (char) Integer.valueOf(strs[i], 16).intValue();
        }
        return returnStr;
    }

    /*
     * 生成12位随机数
     * @return
     * @author huangmj
     * @creed: Talk is cheap,show me the code
     * @date 2019-02-13 14:04
     */
    public static String getOnce() {
        StringBuffer stringBuffer = new StringBuffer();
        Integer count = 0;
        while (count < 12) {
            stringBuffer.append(new Random().nextInt(9));
            count++;
        }
        return stringBuffer.toString();
    }

    /**
     * 字符串拼接% （用于模糊查询）
     *
     * @param s
     * @return
     */
    public static String andLike(String s) {
        if (StringUtils.isBlank(s)) return "";
        return "%" + s + "%";
    }


    /**
     * 自动补零xx位数
     * @param num 要补的参数
     * @param length 要补的长度
     *
     */
    public static String formatZero(long num, int length) {
        return String.format("%0"+length+"d", num);
    }



    /**
     * 获取html片段的汉字及汉字标点符号
     *
     * @param htmlParagraph html字符
     * @return
     */
    public static String accessToChinese(String htmlParagraph) {
        String finalText = "";
        //正则匹配中文及中文标点符号
        String regEx = "[\u4E00-\u9FA5|\\！|\\,|\\。|\\（|\\）|\\《|\\》|\\“|\\”|\\？|\\：|\\；|\\【|\\】]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(htmlParagraph);
        while (m.find()) {
            finalText += m.group();
        }
        //返回Html中的正文以及标点符号
        return finalText;
    }

    /**
     * 从html中提取纯文本
     *
     * @param strHtml html字符
     * @return
     */
    public static String StripHT(String strHtml) {
        //剔出<html>的标签
        String txtcontent = strHtml.replaceAll("</?[^>]+>", "");
        //去除字符串中的空格,回车,换行符,制表符
        txtcontent = txtcontent.replaceAll("<a>\\s*|\t|\r|\n</a>", "");
        return txtcontent;
    }

    /**
     * 去除HTML标签
     *
     * @param html   html字符
     * @param length 保留长度
     * @return
     */
    public static String parseHtml(String html, int length) {
        if (StringUtils.isBlank(html)) return "";
        /*
         * <.*?>为正则表达式，其中的.表示任意字符，*?表示出现0次或0次以上，此方法可以去掉双头标签(双头针对于残缺的标签)
         * "<.*?"表示<尖括号后的所有字符，此方法可以去掉残缺的标签，及后面的内容
         * " "，若有多种此种字符，可用同一方法去除
         */
        html = html.replaceAll("<.*?>", " ").replaceAll("", "");
        html = html.replaceAll("<.*?", "");
        if (html.length() > length) {
            return (html.substring(0, length) + "...");
        }
        return html;
    }

//    /**
//     * 手机号码去重
//     *
//     * @param mobile 手机号字符串，多个用,隔开
//     * @return Set Set集合
//     */
//    public static Set<String> distinctPhone(String mobile) {
//        String[] mobileArr = StringUtil.splits(mobile, CONSTANT.SPLIT_COMMA);
//        Set<String> rtnSet = new HashSet<>();
//        for (String mobilePhone : mobileArr) {
//            // 校验手机号码
//            boolean temp = RegexUtils.checkMobile(mobilePhone);
//            if (temp) {
//                // 验证成功, 添加到集合
//                rtnSet.add(mobilePhone);
//            }
//        }
//        return rtnSet;
//    }

    /**
     * 判断是否为汉字
     *
     * @param str 字符
     * @return
     */
    public static boolean isChinese(String str) {
        String regEx = "[\u4e00-\u9fa5]";
        Pattern pat = Pattern.compile(regEx);
        Matcher matcher = pat.matcher(str);
        boolean flg = false;
        if (matcher.find())
            flg = true;

        return flg;
    }

    /**
     * @param str 待转换字符串
     * @return 转换后字符串
     * @throws UnsupportedEncodingException exception
     * @Description 将字符串中的emoji表情转换成可以在utf-8字符集数据库中保存的格式（表情占4个字节，需要utf8mb4字符集）
     */
    public static String emojiConvert1(String str)
            throws UnsupportedEncodingException {
        String patternString = "([\\x{10000}-\\x{10ffff}\ud800-\udfff])";
        Pattern pattern = Pattern.compile(patternString);
        Matcher matcher = pattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            try {
                matcher.appendReplacement(
                        sb,
                        "[["
                                + URLEncoder.encode(matcher.group(1),
                                "UTF-8") + "]]");
            } catch (UnsupportedEncodingException e) {
                throw e;
            }
        }
        matcher.appendTail(sb);

        return sb.toString();
    }


    /**
     * @param str 转换后的字符串
     * @return 转换前的字符串
     * @throws UnsupportedEncodingException exception
     * @Description 还原utf8数据库中保存的含转换后emoji表情的字符串
     */
    public static String emojiRecovery2(String str)
            throws UnsupportedEncodingException {
        String patternString = "\\[\\[(.*?)\\]\\]";
        Pattern pattern = Pattern.compile(patternString);
        Matcher matcher = pattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            try {
                matcher.appendReplacement(sb,
                        URLDecoder.decode(matcher.group(1), "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                throw e;
            }
        }
        matcher.appendTail(sb);
        return sb.toString();
    }

    public static boolean isNumber(String str) {
        return str.matches("[0-9]+");
    }



}
